package fr.afcepf.atod16.groupe1.projet1.dao;

import fr.afcepf.atod16.groupe1.projet1.dto.Dto;
import fr.afcepf.atod16.groupe1.projet1.dto.administration.DtoCompteEmploye;
import fr.afcepf.atod16.groupe1.projet1.dto.catalogue.DtoCategorieProduit;
import fr.afcepf.atod16.groupe1.projet1.dto.catalogue.DtoFicheProduit;
import fr.afcepf.atod16.groupe1.projet1.dto.catalogue.DtoProduit;
import fr.afcepf.atod16.groupe1.projet1.dto.catalogue.DtoPromo;
import fr.afcepf.atod16.groupe1.projet1.dto.catalogue.DtoSousCategorieProduit;
import fr.afcepf.atod16.groupe1.projet1.dto.catalogue.DtoTVA;
import fr.afcepf.atod16.groupe1.projet1.dto.client.DtoCompteClient;
import fr.afcepf.atod16.groupe1.projet1.dto.commande.DtoCommande;
import fr.afcepf.atod16.groupe1.projet1.dto.commande.DtoLigneCommande;
import fr.afcepf.atod16.groupe1.projet1.entities.Entite;
import fr.afcepf.atod16.groupe1.projet1.entities.administration.CompteEmploye;
import fr.afcepf.atod16.groupe1.projet1.entities.catalogue.CategorieProduit;
import fr.afcepf.atod16.groupe1.projet1.entities.catalogue.FicheProduit;
import fr.afcepf.atod16.groupe1.projet1.entities.catalogue.Produit;
import fr.afcepf.atod16.groupe1.projet1.entities.catalogue.Promo;
import fr.afcepf.atod16.groupe1.projet1.entities.catalogue.SousCategorieProduit;
import fr.afcepf.atod16.groupe1.projet1.entities.catalogue.TVA;
import fr.afcepf.atod16.groupe1.projet1.entities.client.CompteClient;
import fr.afcepf.atod16.groupe1.projet1.entities.commande.Commande;
import fr.afcepf.atod16.groupe1.projet1.entities.commande.LigneCommande;

/**
 * Utilitaire assembleur pour la DAO :<br/>
 * - creation de DTO à partir des entity remontés de la couche de persistance (variables + ManyToOne)<br/>
 * - creation d'entity à partir de DTO pour la creation de nouveaux enregistrements (variables)<br/>
 * - mise à jour d'une entity à partir d'un dto
 *
 * @author cedric
 */
public class DaoAssembleur {

    /**
     * Version générique de la création d'un DTO à partir d'une entité :
     * sous-traite le traitement à la fonction adéquate. 
     * @param entite L'entité à convertir
     * @return Le DTO correspondant
     */
    public static Dto createDto(Entite entite){
        if(entite.getClass().getSimpleName().equals("CompteEmploye")) {
            return (DtoCompteEmploye) DaoAssembleur.createDto((CompteEmploye) entite);
        }
        else if(entite.getClass().getSimpleName().equals("CategorieProduit")) {
            return (DtoCategorieProduit) DaoAssembleur.createDto((CategorieProduit) entite);
        }
        else if(entite.getClass().getSimpleName().equals("FicheProduit")) {
            return (DtoFicheProduit) DaoAssembleur.createDto((FicheProduit) entite);
        }
        else if(entite.getClass().getSimpleName().equals("Promo")) {
            return (DtoPromo) DaoAssembleur.createDto((Promo) entite);
        }
        else if(entite.getClass().getSimpleName().equals("Produit")) {
            return (DtoProduit) DaoAssembleur.createDto((Produit) entite);
        }
        else if(entite.getClass().getSimpleName().equals("SousCategorieProduit")) {
            return (DtoSousCategorieProduit) DaoAssembleur.createDto((SousCategorieProduit) entite);
        }
        else if(entite.getClass().getSimpleName().equals("TVA")) {
            return (DtoTVA) DaoAssembleur.createDto((TVA) entite);
        }
        else if(entite.getClass().getSimpleName().equals("CompteClient")) {
            return (DtoCompteClient) DaoAssembleur.createDto((CompteClient) entite);
        }
        else if(entite.getClass().getSimpleName().equals("Commande")) {
            return (DtoCommande) DaoAssembleur.createDto((Commande) entite);
        }
        else if(entite.getClass().getSimpleName().equals("LigneCommande")) {
            return (DtoLigneCommande) DaoAssembleur.createDto((LigneCommande) entite);
        }
        else {
            return null;
        }
    }
    
    /**
     * Version générique de la création d'une entité à partir d'un DTO :
     * sous-traite le traitement à la fonction adéquate. 
     * @param dto Le DTO à convertir
     * @return L'entité correspondante
     */
    public static Entite createEntity(Dto dto) {
        if(dto.getClass().getSimpleName().equals("DtoCompteEmploye")) {
            return (CompteEmploye) DaoAssembleur.createEntity((DtoCompteEmploye) dto);
        }
        else if(dto.getClass().getSimpleName().equals("DtoCategorieProduit")) {
            return (CategorieProduit) DaoAssembleur.createEntity((DtoCategorieProduit) dto);
        }
        else if(dto.getClass().getSimpleName().equals("DtoFicheProduit")) {
            return (FicheProduit) DaoAssembleur.createEntity((DtoFicheProduit) dto);
        }
        else if(dto.getClass().getSimpleName().equals("DtoPromo")) {
            return (Promo) DaoAssembleur.createEntity((DtoPromo) dto);
        }
        else if(dto.getClass().getSimpleName().equals("DtoProduit")) {
            return (Produit) DaoAssembleur.createEntity((DtoProduit) dto);
        }
        else if(dto.getClass().getSimpleName().equals("DtoSousCategorieProduit")) {
            return (SousCategorieProduit) DaoAssembleur.createEntity((DtoSousCategorieProduit) dto);
        }
        else if(dto.getClass().getSimpleName().equals("DtoTVA")) {
            return (TVA) DaoAssembleur.createEntity((DtoTVA) dto);
        }
        else if(dto.getClass().getSimpleName().equals("DtoCompteClient")) {
            return (CompteClient) DaoAssembleur.createEntity((DtoCompteClient) dto);
        }
        else if(dto.getClass().getSimpleName().equals("DtoCommande")) {
            return (Commande) DaoAssembleur.createEntity((DtoCommande) dto);
        }
        else if(dto.getClass().getSimpleName().equals("DtoLigneCommande")) {
            return (LigneCommande) DaoAssembleur.createEntity((DtoLigneCommande) dto);
        }
        else {
            return null;
        }
    }
    
    /**
     * Version générique de la mise à jour d'une entité avec les informations 
     * d'un DTO : sous-traite le traitement à la fonction adéquate.
     * @param entite L'entité à mettre à jour
     * @param dto Le DTO contenant les informations pour la mise à jour
     */
    public static void updateEntity(Entite entite, Dto dto) {
        if(entite.getClass().getSimpleName().equals("CompteEmploye")) {
            DaoAssembleur.updateEntity((CompteEmploye) entite, (DtoCompteEmploye) dto);
        }
        else if(entite.getClass().getSimpleName().equals("CategorieProduit")) {
            DaoAssembleur.updateEntity((CategorieProduit) entite, (DtoCategorieProduit) dto);
        }
        else if(entite.getClass().getSimpleName().equals("FicheProduit")) {
            DaoAssembleur.updateEntity((FicheProduit) entite, (DtoFicheProduit) dto);
        }
        else if(entite.getClass().getSimpleName().equals("Promo")) {
            DaoAssembleur.updateEntity((Promo) entite, (DtoPromo) dto);
        }
        else if(entite.getClass().getSimpleName().equals("Produit")) {
            DaoAssembleur.updateEntity((Produit) entite, (DtoProduit) dto);
        }
        else if(entite.getClass().getSimpleName().equals("SousCategorieProduit")) {
            DaoAssembleur.updateEntity((SousCategorieProduit) entite, (DtoSousCategorieProduit) dto);
        }
        else if(entite.getClass().getSimpleName().equals("TVA")) {
            DaoAssembleur.updateEntity((TVA) entite, (DtoTVA) dto);
        }
        else if(entite.getClass().getSimpleName().equals("CompteClient")) {
            DaoAssembleur.updateEntity((CompteClient) entite, (DtoCompteClient) dto);
        }
        else if(entite.getClass().getSimpleName().equals("Commande")) {
            DaoAssembleur.updateEntity((Commande) entite, (DtoCommande) dto);
        }
        else if(entite.getClass().getSimpleName().equals("LigneCommande")) {
            DaoAssembleur.updateEntity((LigneCommande) entite, (DtoLigneCommande) dto);
        }
    }
    
    /**
     * Permet de convertir une entité CompteEmploye en DtoCompteEmploye
     * @param produit L'entité
     * @return Le DTO
     */
    public static DtoCompteEmploye createDto(CompteEmploye compteEmploye) {
        DtoCompteEmploye dto = new DtoCompteEmploye();
        dto.setCivilite(compteEmploye.getCivilite());
        dto.setEmail(compteEmploye.getEmail());
        dto.setId(compteEmploye.getId());
        dto.setLogin(compteEmploye.getLogin());
        dto.setNom(compteEmploye.getNom());
        dto.setPass(compteEmploye.getPass());
        dto.setPrenom(compteEmploye.getPrenom());
        dto.setRoleEmploye(compteEmploye.getRoleEmploye());
        return dto;
    }

    /**
     * Permet de convertir un DtoCompteEmploye en entité CompteEmploye
     * @param produit Le DTO
     * @return L'entité
     */
    public static CompteEmploye createEntity(DtoCompteEmploye compteEmploye) {
        CompteEmploye entity = new CompteEmploye();
        entity.setCivilite(compteEmploye.getCivilite());
        entity.setEmail(compteEmploye.getEmail());
        entity.setId(compteEmploye.getId());
        entity.setLogin(compteEmploye.getLogin());
        entity.setNom(compteEmploye.getNom());
        entity.setPass(compteEmploye.getPass());
        entity.setPrenom(compteEmploye.getPrenom());
        entity.setRoleEmploye(compteEmploye.getRoleEmploye());
        return entity;
    }

    /**
     * Met à jour une entité CompteEmploye grace aux informations d'un DtoCompteEmploye
     * @param entity L'entite
     * @param produit Le DTO
     */
    public static void updateEntity(CompteEmploye entity, DtoCompteEmploye compteEmploye) {
        entity.setCivilite(compteEmploye.getCivilite());
        entity.setEmail(compteEmploye.getEmail());
        entity.setId(compteEmploye.getId());
        entity.setLogin(compteEmploye.getLogin());
        entity.setNom(compteEmploye.getNom());
        entity.setPass(compteEmploye.getPass());
        entity.setPrenom(compteEmploye.getPrenom());
        entity.setRoleEmploye(compteEmploye.getRoleEmploye());
    }

    /**
     * Permet de convertir une entité CategorieProduit en DtoCategorieProduit
     * @param produit L'entité
     * @return Le DTO
     */
    public static DtoCategorieProduit createDto(CategorieProduit categorieProduit) {
        DtoCategorieProduit dto = new DtoCategorieProduit();
        dto.setId(categorieProduit.getId());
        dto.setNom(categorieProduit.getNom());
        return dto;
    }

    /**
     * Permet de convertir un DtoCategorieProduit en entité CategorieProduit
     * @param produit Le DTO
     * @return L'entité
     */
    public static CategorieProduit createEntity(DtoCategorieProduit categorieProduit) {
        CategorieProduit entity = new CategorieProduit();
        entity.setId(categorieProduit.getId());
        entity.setNom(categorieProduit.getNom());
        return entity;
    }

    /**
     * Met à jour une entité CategorieProduit grace aux informations d'un DtoCategorieProduit
     * @param entity L'entite
     * @param produit Le DTO
     */
    public static void updateEntity(CategorieProduit entity, DtoCategorieProduit categorieProduit) {
        entity.setId(categorieProduit.getId());
        entity.setNom(categorieProduit.getNom());
    }

    /**
     * Permet de convertir une entité FicheProduit en DtoFicheProduit
     * @param produit L'entité
     * @return Le DTO
     */
    public static DtoFicheProduit createDto(FicheProduit ficheProduit) {
        DtoFicheProduit dto = new DtoFicheProduit();
        dto.setDateCreation(ficheProduit.getDateCreation());
        dto.setDescriptif(ficheProduit.getDescriptif());
        dto.setId(ficheProduit.getId());
        dto.setNom(ficheProduit.getNom());
        if (ficheProduit.getProduit() != null) {
            dto.setProduit(DaoAssembleur.createDto(ficheProduit.getProduit()));
        }
        dto.setResume(ficheProduit.getResume());
        dto.setValide(ficheProduit.getValide());
        return dto;
    }

    /**
     * Permet de convertir un DtoFicheProduit en entité FicheProduit
     * @param produit Le DTO
     * @return L'entité
     */
    public static FicheProduit createEntity(DtoFicheProduit ficheProduit) {
        FicheProduit entity = new FicheProduit();
        entity.setDateCreation(ficheProduit.getDateCreation());
        entity.setDescriptif(ficheProduit.getDescriptif());
        entity.setId(ficheProduit.getId());
        entity.setNom(ficheProduit.getNom());
        entity.setResume(ficheProduit.getResume());
        entity.setValide(ficheProduit.getValide());
        return entity;
    }

    /**
     * Met à jour une entité FicheProduit grace aux informations d'un DtoFicheProduit
     * @param entity L'entite
     * @param produit Le DTO
     */
    public static void updateEntity(FicheProduit entity, DtoFicheProduit ficheProduit) {
        entity.setDateCreation(ficheProduit.getDateCreation());
        entity.setDescriptif(ficheProduit.getDescriptif());
        entity.setId(ficheProduit.getId());
        entity.setNom(ficheProduit.getNom());
        entity.setResume(ficheProduit.getResume());
        entity.setValide(ficheProduit.getValide());
    }

    /**
     * Permet de convertir une entité Promo en DtoPromo
     * @param produit L'entité
     * @return Le DTO
     */
    public static DtoPromo createDto(Promo promo) {
        DtoPromo dto = new DtoPromo();
        dto.setDateDebut(promo.getDateDebut());
        dto.setDateFin(promo.getDateFin());
        dto.setId(promo.getId());
        dto.setRemise(promo.getRemise());
        return dto;
    }

    /**
     * Permet de convertir un DtoPromo en entité Promo
     * @param produit Le DTO
     * @return L'entité
     */
    public static Promo createEntity(DtoPromo promo) {
        Promo entity = new Promo();
        entity.setDateDebut(promo.getDateDebut());
        entity.setDateFin(promo.getDateFin());
        entity.setId(promo.getId());
        entity.setRemise(promo.getRemise());
        return entity;
    }

    /**
     * Met à jour une entité Promo grace aux informations d'un DtoPromo
     * @param entity L'entite
     * @param produit Le DTO
     */
    public static void updateEntity(Promo entity, DtoPromo promo) {
        entity.setDateDebut(promo.getDateDebut());
        entity.setDateFin(promo.getDateFin());
        entity.setId(promo.getId());
        entity.setRemise(promo.getRemise());
    }

    /**
     * Permet de convertir une entité Produit en DtoProduit
     * @param produit L'entité
     * @return Le DTO
     */
    public static DtoProduit createDto(Produit produit) {
        DtoProduit dto = new DtoProduit();
        dto.setCodeEAN13(produit.getCodeEAN13());
        dto.setDateCreation(produit.getDateCreation());
        dto.setId(produit.getId());
        dto.setPrix(produit.getPrix());
        dto.setStock(produit.getStock());
        if (produit.getTva() != null) {
            dto.setTva(DaoAssembleur.createDto(produit.getTva()));
        }
        return dto;
    }

    /**
     * Permet de convertir un DtoProduit en entité Produit
     * @param produit Le DTO
     * @return L'entité
     */
    public static Produit createEntity(DtoProduit produit) {
        Produit entity = new Produit();
        entity.setCodeEAN13(produit.getCodeEAN13());
        entity.setDateCreation(produit.getDateCreation());
        entity.setId(produit.getId());
        entity.setPrix(produit.getPrix());
        entity.setStock(produit.getStock());
        entity.setTva(createEntity(produit.getTva()));
        return entity;
    }

    /**
     * Met à jour une entité Produit grace aux informations d'un DtoProduit
     * @param entity L'entite
     * @param produit Le DTO
     */
    public static void updateEntity(Produit entity, DtoProduit produit) {
        entity.setCodeEAN13(produit.getCodeEAN13());
        entity.setDateCreation(produit.getDateCreation());
        entity.setId(produit.getId());
        entity.setPrix(produit.getPrix());
        entity.setStock(produit.getStock());
    }

    /**
     * Permet de convertir une entité SousCategorieProduit en DtoSousCategorieProduit
     * @param produit L'entité
     * @return Le DTO
     */
    public static DtoSousCategorieProduit createDto(SousCategorieProduit sousCategorieProduit) {
        DtoSousCategorieProduit dto = new DtoSousCategorieProduit();
        dto.setId(sousCategorieProduit.getId());
        dto.setNom(sousCategorieProduit.getNom());
        if (sousCategorieProduit.getCategorie() != null) {
            dto.setCategorie(DaoAssembleur.createDto(sousCategorieProduit.getCategorie()));
        }
        return dto;
    }

    /**
     * Permet de convertir un DtoSousCategorieProduit en entité SousCategorieProduit
     * @param produit Le DTO
     * @return L'entité
     */
    public static SousCategorieProduit createEntity(DtoSousCategorieProduit sousCategorieProduit) {
        SousCategorieProduit entity = new SousCategorieProduit();
        entity.setId(sousCategorieProduit.getId());
        entity.setNom(sousCategorieProduit.getNom());
        return entity;
    }

    /**
     * Met à jour une entité SousCategorieProduit grace aux informations d'un DtoSousCategorieProduit
     * @param entity L'entite
     * @param produit Le DTO
     */
    public static void updateEntity(SousCategorieProduit entity, DtoSousCategorieProduit sousCategorieProduit) {
        entity.setId(sousCategorieProduit.getId());
        entity.setNom(sousCategorieProduit.getNom());
    }

    /**
     * Permet de convertir une entité TVA en DtoTVA
     * @param produit L'entité
     * @return Le DTO
     */
    public static DtoTVA createDto(TVA tva) {
        DtoTVA dto = new DtoTVA();
        dto.setId(tva.getId());
        dto.setTaux(tva.getTaux());
        return dto;
    }

    /**
     * Permet de convertir un DtoTVA en entité TVA
     * @param produit Le DTO
     * @return L'entité
     */
    public static TVA createEntity(DtoTVA tva) {
        TVA entity = new TVA();
        entity.setId(tva.getId());
        entity.setTaux(tva.getTaux());
        return entity;
    }

    /**
     * Met à jour une entité TVA grace aux informations d'un DtoTVA
     * @param entity L'entite
     * @param produit Le DTO
     */
    public static void updateEntity(TVA entity, DtoTVA tva) {
        entity.setId(tva.getId());
        entity.setTaux(tva.getTaux());
    }

    /**
     * Permet de convertir une entité CompteClient en DtoCompteClient
     * @param produit L'entité
     * @return Le DTO
     */
    public static DtoCompteClient createDto(CompteClient compteClient) {
        DtoCompteClient dto = new DtoCompteClient();
        dto.setActif(compteClient.getActif());
        dto.setAdresse(compteClient.getAdresse());
        dto.setCivilite(compteClient.getCivilite());
        dto.setCodePostal(compteClient.getCodePostal());
        dto.setEmail(compteClient.getEmail());
        dto.setId(compteClient.getId());
        dto.setNom(compteClient.getNom());
        dto.setPass(compteClient.getPass());
        dto.setPrenom(compteClient.getPrenom());
        dto.setTelFixe(compteClient.getTelFixe());
        dto.setTelMobile(compteClient.getTelMobile());
        dto.setVille(compteClient.getVille());
        return dto;
    }

    /**
     * Permet de convertir un DtoCompteClient en entité CompteClient
     * @param produit Le DTO
     * @return L'entité
     */
    public static CompteClient createEntity(DtoCompteClient compteClient) {
        CompteClient entity = new CompteClient();
        entity.setActif(compteClient.getActif());
        entity.setAdresse(compteClient.getAdresse());
        entity.setCivilite(compteClient.getCivilite());
        entity.setCodePostal(compteClient.getCodePostal());
        entity.setEmail(compteClient.getEmail());
        entity.setId(compteClient.getId());
        entity.setNom(compteClient.getNom());
        entity.setPass(compteClient.getPass());
        entity.setPrenom(compteClient.getPrenom());
        entity.setTelFixe(compteClient.getTelFixe());
        entity.setTelMobile(compteClient.getTelMobile());
        entity.setVille(compteClient.getVille());
        return entity;
    }

    /**
     * Met à jour une entité CompteClient grace aux informations d'un DtoCompteClient
     * @param entity L'entite
     * @param produit Le DTO
     */
    public static void updateEntity(CompteClient entity, DtoCompteClient compteClient) {
        entity.setActif(compteClient.getActif());
        entity.setAdresse(compteClient.getAdresse());
        entity.setCivilite(compteClient.getCivilite());
        entity.setCodePostal(compteClient.getCodePostal());
        entity.setEmail(compteClient.getEmail());
        entity.setId(compteClient.getId());
        entity.setNom(compteClient.getNom());
        entity.setPass(compteClient.getPass());
        entity.setPrenom(compteClient.getPrenom());
        entity.setTelFixe(compteClient.getTelFixe());
        entity.setTelMobile(compteClient.getTelMobile());
        entity.setVille(compteClient.getVille());
    }

    /**
     * Permet de convertir une entité Comande en DtoCommande
     * @param produit L'entité
     * @return Le DTO
     */
    public static DtoCommande createDto(Commande commande) {
        DtoCommande dto = new DtoCommande();
        dto.setAdresseFacturation(commande.getAdresseFacturation());
        dto.setAdresseLivraison(commande.getAdresseLivraison());
        dto.setCiviliteFacturation(commande.getCiviliteFacturation());
        dto.setCiviliteLivraison(commande.getCiviliteLivraison());
        dto.setCodePostalFacturation(commande.getCodePostalFacturation());
        dto.setCodePostalLivraison(commande.getCodePostalLivraison());
        if (commande.getCompteClient() != null) {
            dto.setCompteClient(DaoAssembleur.createDto(commande.getCompteClient()));
        }
        dto.setDateCreation(commande.getDateCreation());
        dto.setEtatLivraison(commande.getEtatLivraison());
        dto.setFraisLivraison(commande.getFraisLivraison());
        dto.setId(commande.getId());
        dto.setModeLivraison(commande.getModeLivraison());
        dto.setNomFacturation(commande.getNomFacturation());
        dto.setNomLivraison(commande.getNomLivraison());
        dto.setPaiement(commande.getPaiement());
        dto.setPrenomFacturation(commande.getPrenomFacturation());
        dto.setPrenomLivraison(commande.getPrenomLivraison());
        dto.setTelFixeFacturation(commande.getTelFixeFacturation());
        dto.setTelFixeLivraison(commande.getTelFixeLivraison());
        dto.setTelMobileFacturation(commande.getTelMobileFacturation());
        dto.setTelMobileLivraison(commande.getTelMobileLivraison());
        dto.setTotal(commande.getTotal());
        dto.setVilleFacturation(commande.getVilleFacturation());
        dto.setVilleLivraison(commande.getVilleLivraison());
        return dto;
    }

    /**
     * Permet de convertir un DtoCommande en entité Commande
     * @param produit Le DTO
     * @return L'entité
     */
    public static Commande createEntity(DtoCommande commande) {
        Commande entity = new Commande();
        entity.setAdresseFacturation(commande.getAdresseFacturation());
        entity.setAdresseLivraison(commande.getAdresseLivraison());
        entity.setCiviliteFacturation(commande.getCiviliteFacturation());
        entity.setCiviliteLivraison(commande.getCiviliteLivraison());
        entity.setCodePostalFacturation(commande.getCodePostalFacturation());
        entity.setCodePostalLivraison(commande.getCodePostalLivraison());
        entity.setDateCreation(commande.getDateCreation());
        entity.setEtatLivraison(commande.getEtatLivraison());
        entity.setFraisLivraison(commande.getFraisLivraison());
        entity.setId(commande.getId());
        entity.setModeLivraison(commande.getModeLivraison());
        entity.setNomFacturation(commande.getNomFacturation());
        entity.setNomLivraison(commande.getNomLivraison());
        entity.setPaiement(commande.getPaiement());
        entity.setPrenomFacturation(commande.getPrenomFacturation());
        entity.setPrenomLivraison(commande.getPrenomLivraison());
        entity.setTelFixeFacturation(commande.getTelFixeFacturation());
        entity.setTelFixeLivraison(commande.getTelFixeLivraison());
        entity.setTelMobileFacturation(commande.getTelMobileFacturation());
        entity.setTelMobileLivraison(commande.getTelMobileLivraison());
        entity.setTotal(commande.getTotal());
        entity.setVilleFacturation(commande.getVilleFacturation());
        entity.setVilleLivraison(commande.getVilleLivraison());
        entity.setCompteClient(createEntity(commande.getCompteClient()));
        return entity;
    }

    /**
     * Met à jour une entité Commande grace aux informations d'un DtoCommande
     * @param entity L'entite
     * @param produit Le DTO
     */
    public static void updateEntity(Commande entity, DtoCommande commande) {
        entity.setAdresseFacturation(commande.getAdresseFacturation());
        entity.setAdresseLivraison(commande.getAdresseLivraison());
        entity.setCiviliteFacturation(commande.getCiviliteFacturation());
        entity.setCiviliteLivraison(commande.getCiviliteLivraison());
        entity.setCodePostalFacturation(commande.getCodePostalFacturation());
        entity.setCodePostalLivraison(commande.getCodePostalLivraison());
        entity.setDateCreation(commande.getDateCreation());
        entity.setEtatLivraison(commande.getEtatLivraison());
        entity.setFraisLivraison(commande.getFraisLivraison());
        entity.setId(commande.getId());
        entity.setModeLivraison(commande.getModeLivraison());
        entity.setNomFacturation(commande.getNomFacturation());
        entity.setNomLivraison(commande.getNomLivraison());
        entity.setPaiement(commande.getPaiement());
        entity.setPrenomFacturation(commande.getPrenomFacturation());
        entity.setPrenomLivraison(commande.getPrenomLivraison());
        entity.setTelFixeFacturation(commande.getTelFixeFacturation());
        entity.setTelFixeLivraison(commande.getTelFixeLivraison());
        entity.setTelMobileFacturation(commande.getTelMobileFacturation());
        entity.setTelMobileLivraison(commande.getTelMobileLivraison());
        entity.setTotal(commande.getTotal());
        entity.setVilleFacturation(commande.getVilleFacturation());
        entity.setVilleLivraison(commande.getVilleLivraison());
    }

    /**
     * Permet de convertir une entité LigneCommande en DtoLigneCommande
     * @param produit L'entité
     * @return Le DTO
     */
    public static DtoLigneCommande createDto(LigneCommande ligneCommande) {
        DtoLigneCommande dto = new DtoLigneCommande();
        if (ligneCommande.getCommande() != null) {
            dto.setCommande(DaoAssembleur.createDto(ligneCommande.getCommande()));
        }
        dto.setId(ligneCommande.getId());
        dto.setPrixUnitaire(ligneCommande.getPrixUnitaire());
        if (ligneCommande.getProduit() != null) {
            dto.setProduit(DaoAssembleur.createDto(ligneCommande.getProduit()));
        }
        dto.setQuantite(ligneCommande.getQuantite());
        dto.setRemise(ligneCommande.getRemise());
        dto.setTauxTVA(ligneCommande.getPrixUnitaire());
        return dto;
    }

    /**
     * Permet de convertir un DtoLigneCommande en entité LigneCommande
     * @param produit Le DTO
     * @return L'entité
     */
    public static LigneCommande createEntity(DtoLigneCommande ligneCommande) {
        LigneCommande entity = new LigneCommande();
        entity.setId(ligneCommande.getId());
        entity.setPrixUnitaire(ligneCommande.getPrixUnitaire());
        entity.setQuantite(ligneCommande.getQuantite());
        entity.setRemise(ligneCommande.getRemise());
        entity.setTauxTVA(ligneCommande.getPrixUnitaire());
        return entity;
    }

    /**
     * Met à jour une entité LigneCommande grace aux informations d'un DtoLigneCommande
     * @param entity L'entite
     * @param produit Le DTO
     */
    public static void updateEntity(LigneCommande entity, DtoLigneCommande ligneCommande) {
        entity.setId(ligneCommande.getId());
        entity.setPrixUnitaire(ligneCommande.getPrixUnitaire());
        entity.setQuantite(ligneCommande.getQuantite());
        entity.setRemise(ligneCommande.getRemise());
        entity.setTauxTVA(ligneCommande.getPrixUnitaire());
    }
}
